n = eval(input())
s = []
count = 0
if n < 0 or type(n) != int:
    print("ERROR")
else:
    while n != 1:
        s.append(n)
        count+=1
        if n % 2 == 0:
            n = n // 2
        else:
            n = n * 3 + 1
    s.append(1)
    for i in s:
        print(i, end=" ")
    print()
    print(count)




# 请补充你的代码
import math
def y(x):
    return (pow(x,3)*math.cos(x/2)+0.5*math.sqrt(4-x*x))
a = -2
b = 2
n = int(input())

h = (b-a)/n
area = 0.5*(y(a)+y(b))
for i in range(1,n):
    x = a+i*h
    area+=y(x)
area*=h
print(f'wifi密码是:{area:.8f}')



"""
在同一行内输入用空格分隔的两个整数，代表头和脚的数量，计算并输出笼中各有多少只鸡和兔，
如无解则输出“Data Error!”，函数无返回值。
输入：35 94
输出：有23 只鸡，12 只兔
输入：100 5
输出：Data Error!
"""
head,feet = map(int, input().split()) #读入以空格分隔的两个整数，表示头和脚的数量
##############Begin#####################
flag = True
for i in range(0,head+1):
    if i*2+(head-i)*4==feet:
        print(f'有{i}只鸡，{head-i}只兔')
        flag = False
if flag:
    print("Data Error!")




##############End#####################




"""一些物品，不知道有多少个，3个3个数的话，还多出2个；5个5个数则多出3个；
7个7个数也会多出2个。输入一个正整数，从小到大依次输出所有不超过输入数字
且满足条件的物品数量，有多个答案时每行输出一个。
例如输入：200
输出：
23
128
"""
n = int(input())
##############Begin#####################
flag = True
for i in range(1,n+1):
    if i%3==2 and i%5==3 and i%7==2:
        print(i)
        flag = False
if flag:
    print("No solution!")




##############End#####################




"""有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打洞一尺，小老鼠也是打洞一尺。
大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。计算并输出它们几天可以相逢，
相逢时各打了多少尺。
输入格式：输入1 个整数，代表墙的厚度，单位为尺
输出格式：
第一行输出1 个整数，表示相遇时所需的天数
第二行输出2 个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，保留小数点后1 位数字。
"""
wall = int(input()) #墙壁的厚度
rat, mouse, day, time = 1, 1, 0, 1 #大鼠速度、小鼠速度、天数、当天工作时长（1表示工作一整天）
distance_of_rat, distance_of_mouse = 0, 0 #大鼠路程、小鼠的路程
while wall > 0:
################Begin#######################
    if wall - rat - mouse < 0:
        time = wall / (rat + mouse)
        break
    wall -= (rat + mouse)
    day += 1
    distance_of_rat += rat
    distance_of_mouse += mouse
    rat *= 2
    mouse /= 2
if time < 1:
    day+=1
distance_of_rat +=rat*time
distance_of_mouse +=mouse*time
################End#######################
print(day)
print(round(distance_of_mouse, 1), round(distance_of_rat, 1)) #使用round函数来保留小数点后一位



"""有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，
已知共有765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。
输出为8行，每行都是一个正整数，从上往下数字依次增大，每个数字代表本层宝塔上的琉璃灯数目。
"""
first = 1
total_lanterns = 765
lantern = []

m = first
for i in range(8):
    lantern.append(m)
    m = m * 2

x = total_lanterns // sum(lantern)

for i in range(len(lantern)):
    lantern[i] = lantern[i] * x

for layer in range(len(lantern)):
    print(lantern[layer])



"""大诗人李白，提着酒壶，从家里出来，酒壶中有酒若干。他边走边唱：无事街上走，提壶去买酒，
遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
"""
#解题思路：让李白按路线逆向走一遍
wine =0  #最后酒壶空了
################Begin#################
for i in range(5):
    if i %2 ==0:
        wine-=1
    else:
        wine*=2

################End#################
print(0.96875) #原来有多少斗酒



#  补充你的代码
import math
a = float(input())
b = float(input())
c = float(input())
if a+b>c and a+c >b and b+c >a:
    print("True")
else:
    print("False")

#  补充你的代码
sides = sorted([float(input()),
                float(input()),
                float(input())])
if sides[0] > 0:
    if sides[0] ** 2 + sides[1] ** 2 == sides[2] ** 2:
        print("True")
    else:
        print("False")
else:
    print("False")




#  补充你的代码
import math
a = float(input())
b = float(input())
c = float(input())

if a + b > c and a + c > b and b + c > a:

    if a == b or b == c or a == c:
        print("True")
    else:
        print("False")
else:
    print("False")

#  补充你的代码
import math

a = eval(input())
b = eval(input())
c = eval(input())
if a + b > c and a + c > b and b + c > a:
    s = (a + b + c) / 2
    area = math.sqrt(s * (s - a) * (s - b) * (s - c))
    print(round(area, 2))
else:
    print("data error")

#  补充你的代码
import math

a = eval(input())
b = eval(input())
c = eval(input())
if a + b > c and a + c > b and b + c > a:
    s = (a + b + c) / 2
    area = math.sqrt(s * (s - a) * (s - b) * (s - c))
    cr = a * b * c / 4 / area
    cArea = cr * cr * math.pi
    print(round(cArea, 2))
else:
    print("data error")


# 补充你的代码
import math
Q = 5201
M = 22
a = 6323
r = int(input())
t = 365
K = 57.48
print(f"预测距离为{r}米时十年间地下水位下降幅度为：", end="")
for i in range(1, 11):
    s = Q / (2 * math.pi * K * M) * math.log((2.25 * a * i * t) / r**2)
    print(round(s, 2), end=" ")



import math

q = 5201  # 开采水量
m = 22  # 含水层厚度
k = 57.48  # 渗透系数
a = 6323  # 导压系数
t = 365  # 开采时间
# 表格首行格式
print(f'|{"预测距离":<5}|{1:<6}|{2:<6}|{3:<6}|{4:<6}|{5:<6}|{6:<6}|{7:<6}|{8:<6}|{9:<6}|{10:<6}|')
# 补充你的代码
for r in [0.5, 1, 5, 10, 20, 30, 50, 100, 200, 500, 1000, 2200]:
    print(f"|{r:<8}", end="")
    for i in range(1, 11):
        s = q / (2 * math.pi * k * m) * math.log((2.25 * a * i * t) / r**2)
        print(f"|{round(s, 2):<6}", end="")
    print("|")



def is_prime(x):
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True
def is_huiwen(x):
    x_str = str(x)
    x1 = x_str[::-1]
    return x1 == x_str

x = int(input())
n = 2
count = 0
while(count<x):
    if is_prime(n) and is_huiwen(n):
        print(n,end =' ')
        count+=1
    n+=1



def is_prime(x):
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True

def is_huiwen(x):
        x_str = str(x)
        x1 = x_str[::-1]
        return x1 == x_str
def reverse_num(x):
    return int(str(x)[::-1])

x = int(input())
n = 10
count = 0
reverse_prime = []

while count<x:
    if is_prime(n) and is_prime(reverse_num(n)) and not is_huiwen(n) and not is_huiwen(reverse_num(n)):
        print(n,end =' ')
        count+=1
    n+=1



# 请输入你的代码

# 初始参数
initial_price = 15  # 每股买入价格
shares = 5500       # 股票数量
days = 15           # 涨停天数
daily_increase_rate = 0.10  # 每日涨停幅度（10%）

# 计算15天后的股票价格
final_price = initial_price * (1 + daily_increase_rate) ** days

# 计算卖出时的总金额
sell_total = final_price * shares

# 计算买入时的总成本
buy_total = initial_price * shares

# 计算获利
profit = sell_total - buy_total

# 输出获利结果，保留2位小数
print(f'{profit:.2f}')




def money_made(num_shares, purchase_share_price, current_share_price):
    """
    计算股票交易的收益。

    参数:
    num_shares (int): 购买的股票数量。
    purchase_share_price (float): 每股的购买价格。
    current_share_price (float): 当前每股的价格。

    返回:
    float: 股票交易的收益，计算公式为股票数量乘以每股的价格差。
    """
    # 补充计算语句和返回值语句
    return num_shares * (current_share_price - purchase_share_price)


# 主程序输入部分
num = int(input())
purchase = float(input())
current = float(input())
# 补充调用函数获取计算结果的语句
profit = money_made(num, purchase, current)
# 补充输出结果的语句，保留2位小数
print(round(profit,2))




def pow(x, n):  # 幂运算函数
    """接收一个数字x和一个整数n为参数,返回x的n次幂的结果的浮点数类型
    要求使pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0"""
    #########################Begin###############################
    if x == 1 or n == 0:
        return 1.0
    else:
        tmp = x
        for i in range(2,n+1):
            x*=tmp
        return x


    #########################End###############################



if __name__ == '__main__':
    x = float(input())
    n = int(input())
    return_data = pow(x,n)
    print(return_data)




def gcd(a, b):
    """接收两个正整数为参数，返回两个数的最大公约数"""
    #######################Begin############################
    m = max(a,b)
    n = min(a,b)
    r = m%n
    while r!=0:
        m = n
        n = r
        r = m%n
    return n
    #######################End############################

if __name__ == '__main__':
    a = int(input())
    b = int(input())
    return_data = gcd(a,b)
    print(return_data)




def lcm(a, b):
    """接收两个正整数为参数，以整数类型返回两个数的最小公倍数"""
    ######################Begin###############################
    x = a*b
    while a!=b:
        if a>b:
            a = a-b
        else:
            b = b-a
    return x//a
    ######################End###############################

if __name__ == '__main__':
    a = int(input())
    b = int(input())
    return_data = lcm(a,b)
    print(return_data)




def fabs(x):
    """返回x的绝对值"""
    ######################Begin###############################
    return -x if x<0 else x



    ######################End###############################

if __name__ == '__main__':
    x = float(input())
    return_data = fabs(x)
    print(return_data)



def ceil(x):
    """接受一个浮点数或整数，返回大于或等于该数的最小整数"""
    ######################Begin###############################
    if x - int(x)>0:
        x = int(x+1)
        return x
    elif -x - (-(int(x))) >0:
        x=int(x)
        return x
    else:
        return x



    ######################End###############################

if __name__ == '__main__':
    x = eval(input())
    return_data = ceil(x)
    print(return_data)


def floor(x):
    """接受一个浮点数或整数，返回不大于该数的最大整数"""
    ######################Begin###############################
    if x - int(x) > 0:
        x = int(x)
        return x
    elif -x - (-(int(x))) > 0:
        x = int(x) - 1
        return x
    else:
        return x

    ######################End###############################


if __name__ == '__main__':
    x = eval(input())
    return_data = floor(x)
    print(return_data)





def factorial(n):
    """接收一个非负整数n为参数，返回n的阶乘，0的阶乘值为1"""
    ######################Begin###############################
    if n==0:
        return 1
    else:
        res =1
        for i in range(1,n+1):
            res*=i
        return res



    ######################End###############################

if __name__ == '__main__':
    x = int(input())
    return_data = factorial(x)
    print(return_data)




def fsum(iterable):
    """接收一个元素为数值的序列为参数，以浮点数类型返回各元素之和"""
    ######################Begin###############################
    al = 0.0
    for i in iterable:
        al+=float(i)
    return al



    ######################End###############################


if __name__ == '__main__':
    x = list(map(eval, input().split()))
    return_data = fsum(x)
    print(return_data)


def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，返回值是布尔类型。参数是素数时返回True，否则返回False"""
    # ==================Begin=================================
    # 补充你的代码
    if x < 2:
        return False
    for i in range(2, int(x ** 0.5) + 1):
        if x % i == 0:
            return False
    return True

    # ===================End================================


positive_int = int(input())  # 输入一个正整数
if is_prime(positive_int):
    print(f'{positive_int}是素数')
else:
    print(f'{positive_int}不是素数')


def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True
    #=======================End================================


def output_prime(n):
    """接收一个正整数为参数，遍历从0到number之间的所有整数
    在一行中输出不大于number的所有素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(1,n+1):
        if is_prime(i):
            print(i,end=' ')

    #=======================End================================


positive_int = int(input())
output_prime(positive_int)



def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True
    #=========================End==============================

def is_huiwen(x):
        x_str = str(x)
        x1 = x_str[::-1]
        return x1 == x_str

def plalindrome_prime(n):
    """接收一个正整数参数number，遍历从0到number之间的所有整数，
    若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
    找出并在同一行中输出小于number的所有回文素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(1,n):
        if is_prime(i) and is_huiwen(i):
             print(i,end = ' ')
    #=========================End==============================


positive_int = int(input())
plalindrome_prime(positive_int)




def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True
    #========================End===============================

def is_huiwen(x):
        x_str = str(x)
        x1 = x_str[::-1]
        return x1 == x_str
def reverse_num(x):
    return int(str(x)[::-1])

def reverse_prime(n):
    """接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，每个数字后一个空格。
    反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串。函数无返回值"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(1,n):
        if is_prime(i) and is_prime(reverse_num(i)) and not is_huiwen(i) and not is_huiwen(reverse_num(i)):
            print(i,end =' ')
    #========================End===============================


positive_int = int(input())
reverse_prime(positive_int)



def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True
    #========================End===============================

def is_huiwen(x):
        x_str = str(x)
        x1 = x_str[::-1]
        return x1 == x_str
def reverse_num(x):
    return int(str(x)[::-1])

def reverse_prime(n):
    """接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，每个数字后一个空格。
    反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串。函数无返回值"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(1,n):
        if is_prime(i) and is_prime(reverse_num(i)) and not is_huiwen(i) and not is_huiwen(reverse_num(i)):
            print(i,end =' ')
    #========================End===============================


positive_int = int(input())
reverse_prime(positive_int)


def print_hi_human():  # 函数名用小写字母
    """文档注释，双引号，说明函数的参数、功能和返回值等。
    定义一个名为print_hi_human的无参数函数，其功能是打印一句问候语，
    这个函数没有return语句，即没有返回值，或者说其返回值为None。
    # >>> print_hi_human()
    # 人类，你好！
    """
    # ==================Begin=====================================
    # 此处去掉注释符号“#”并补充你的代码
    print("人类，你好！")
    # ===================End====================================

if __name__ == '__main__':
    # 直接使用函数名来调用函数
    # ==================Begin=====================================
    # 此处去掉注释符号“#”并补充你的代码
    print_hi_human()
    # ===================End====================================



def say_hi_human():  # 函数名用小写字母
    """定义一个名为print_hi_human的无参数函数，其功能是返回字符串-人类，你好！"""
    #========================Begin===============================
    #补充你的代码
    print("人类，你好！")
    #==========================End=============================

if __name__ == '__main__':
    # 函数名作为print()函数的参数，输出say_hi_human()的返回值
    #========================Begin===============================
    #补充你的代码
    say_hi_human()
    #==========================End=============================




def say_hi_person(full_name):  # 函数名用小写字母，函数名填空
    """定义一个名为say_hi_person的有参数函数，接受人名的字符串为参数，函数的返回值为“***，你好！”，
    例如函数的参数为“李白”，返回值为“李白，你好！”。"""
    #====================Begin===================================
    # 补充你的代码
    print(full_name+"，你好！")
    #=====================End==================================

if __name__ == '__main__':
    #  函数名作为print()函数的参数，输出say_hi_human()的返回值。输入的人名作为函数的参数
    person_name = input()              # 输入人名
    #====================Begin===================================
    # 补充你的代码
    say_hi_person(person_name)
    #=====================End==================================


def say_hi_person(full_name):  # 函数名用小写字母，函数名填空
    """定义一个名为say_hi_person的有参数函数，接受人名的字符串为参数，函数的返回值为“***，你好！”，
    例如函数的参数为“李白”，返回值为“李白，你好！”。"""
    #====================Begin===================================
    # 补充你的代码
    print(full_name+"，你好！")
    #=====================End==================================

if __name__ == '__main__':
    #  函数名作为print()函数的参数，输出say_hi_human()的返回值。输入的人名作为函数的参数
    person_name = input()              # 输入人名
    #====================Begin===================================
    # 补充你的代码
    say_hi_person(person_name)
    #=====================End==================================


def say_hi_person(full_name):  # 函数名用小写字母，函数名填空
    """定义一个名为say_hi_person的有参数函数，接受人名的字符串为参数，函数的返回值为“***，你好！”，
    例如函数的参数为“李白”，返回值为“李白，你好！”。"""
    #====================Begin===================================
    # 补充你的代码
    print(full_name+"，你好！")
    #=====================End==================================

if __name__ == '__main__':
    #  函数名作为print()函数的参数，输出say_hi_human()的返回值。输入的人名作为函数的参数
    person_name = input()              # 输入人名
    #====================Begin===================================
    # 补充你的代码
    say_hi_person(person_name)
    #=====================End==================================


def pow(x,n):
    result = 1
    for _ in range(n):
        result *= x
    return result
x = float(input())
n = int(input())
result = pow(x, n)
print(float(result))


def fabs(x):
    """返回x的绝对值"""
    # 补充你的代码
    return -x if x < 0 else x


if __name__ == '__main__':
    n = float(input())
    print(fabs(n))


def Car(year, model, brand="宝马"): # 括号里补充你的代码
#####
    return f"这是一辆{year}年生产，型号是{model}的{brand}牌汽车。"
# 以下内容不要修改
ls = input().split()  # 根据空格切分输入字符串为列表
print(Car(*ls))       # 调用函数，取列表中的全部数据做参数


def Car(year, model, brand="宝马"): # 括号里补充你的代码
#####
    return f"这是一辆{year}年生产，型号是{model}的{brand}牌汽车。"
# 以下内容不要修改
ls = input().split()  # 根据空格切分输入字符串为列表
print(Car(*ls))       # 调用函数，取列表中的全部数据做参数



import math
def sqrt_binary(n,p):
    left, right = 0, n + 0.25
    while True:
        mid = (left+right)/2
        if abs(mid*mid-n) <=p:
            return mid
        elif mid*mid>n:
            right = mid
        else:
            left = mid

n,p = input().split(',')
n,p = float(n),float(p)
res1 = sqrt_binary(n,p)
res2 = math.sqrt(n)

print(f"{res1:.8f}")
print(f"{res2:.8f}")

"""函数名is_prime()不允许修改，判断素数的函数,接收一个正整数为参数，返回值是布尔类型。参数是素数时返回True，否则返回False"""
'''本代码只用来定义函数，测试用例会通过调用本文件定义的函数来进行测试'''


def is_prime(x):
    if x < 2:
        return False
    for i in range(2, int(x ** 0.5) + 1):
        if x % i == 0:
            return False
    return True







def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True
    #=========================End==============================

def is_huiwen(x):
        x_str = str(x)
        x1 = x_str[::-1]
        return x1 == x_str

def plalindrome_prime(n):
    """接收一个正整数参数number，遍历从0到number之间的所有整数，
    若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
    找出并在同一行中输出小于number的所有回文素数，每个数字后一个空格，函数无返回值。"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(1,n):
        if is_prime(i) and is_huiwen(i):
             print(i,end = ' ')
    #=========================End==============================


positive_int = int(input())
plalindrome_prime(positive_int)

def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False。减小判定区间，减少循环次数，提升效率"""
    #======================Begin=================================
    # 补充你的代码
    if x<2:
        return False
    for i in range(2,int(x**0.5)+1):
        if x%i==0:
            return False
    return True
    #========================End===============================

def is_huiwen(x):
        x_str = str(x)
        x1 = x_str[::-1]
        return x1 == x_str
def reverse_num(x):
    return int(str(x)[::-1])

def reverse_prime(n):
    """接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，每个数字后一个空格。
    反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串。函数无返回值"""
    #======================Begin=================================
    # 补充你的代码
    for i in range(1,n):
        if is_prime(i) and is_prime(reverse_num(i)) and not is_huiwen(i) and not is_huiwen(reverse_num(i)):
            print(i,end =' ')
    #========================End===============================


positive_int = int(input())
reverse_prime(positive_int)


def is_prime(x):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False"""
    # ====================Begin===================================
    # 补充你的代码
    if x < 2:
        return False
    for i in range(2, int(x ** 0.5) + 1):
        if x % i == 0:
            return False
    return True
    # ======================End=================================


def goldbach_conjecture(n):
    """ 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
    当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
    有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
    参数为奇数或小于4时，输出'Data error!'
    """
    # ====================Begin===================================
    # 补充你的代码
    if n < 4 or n % 2 != 0:
        print("Data error!")
        return
    for i in range(2, n // 2 + 1):
        if is_prime(i) and is_prime(n - i):
            print(f'{n}={i}+{n - i}')
    # ======================End=================================


if __name__ == '__main__':
    positive_even = int(input())  # 输入一个正数
    goldbach_conjecture(positive_even)


def is_leap(year):
    """判断year是否为闰年，闰年返回True，非闰年返回False"""
#####
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)


def days_of_month(date_str):
    """根据输入的年月日，返回该月的天数"""
#####
    year = int(date_str[:4])
    month = int(date_str[4:6])
    days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if month == 2 and is_leap(year):
        return 29
    return days_in_month[month - 1]


if __name__ == '__main__':
    date_in = input()  # 输入一个年月日
    print(days_of_month(date_in))


    def celsius(na):  # 函数
        C = 5 * (na - 32) / 9
        return C
ac, bd = map(int, input().split(","))  # 一行输入a,b
if ((ac > bd) or (ac < 32)):
    print("error")
else:
    for i in range(ac, bd + 1, 2):  # 步数为2
        print('{} : {:.2f}'.format(i, celsius(i)))  # 函数调用




def oddsum(sa):
    al = 0
    for char in sa:
        if char.isdigit():
            num = int(char)
            if num%2!=0:
                al+=num
    return al

def evensum(sa):
    al = 0
    for char in sa:
        if char.isdigit():
            num = int(char)
            if num%2==0:
                al+=num
    return al

sa= input()

print('oddsum={},evensum={}'.format(oddsum(sa), evensum(sa)))



def is_con(st,na):
    return all(char in na for char in st)

def main():
    st = input()
    if not st.isalpha():
        print("ERROR")
        return

    na = input()
    if is_con(st, na):
        print("FOUND")
    else:
        print("NOT FOUND")
main()